package com.kt.common.skip

/**
 * return。默认从最直接包围它的函数或者匿名函数返回。
 *break。终止最直接包围它的循环。
 *continue。继续下一次最直接包围它的循环。
 */
fun main() {
    /*val person = Person()
    person.name = "zs"
    val s = person.name ?: return
    println(s)
*/
    //可以添加标记标签abc@   ...
    /*println("continue")
    loop@ for (i in 1..10) {
        if (i in 2..5) continue
        println(i)
    }
    println("break")
    loop@ for (i in 1..10) {
        if (i in 2..5) break
        println(i)
    }
    println("return")
    loop@ for (i in 1..10) {
        if (i in 2..5) return
        println(i)
    }

    println("end")*/



    //foo4()

    println(Person.Resource)
}

/**使用lambda表达式 return 不适用标签会直接返回到外层函数，即外层函数的作用域
 *如果需要让外层函数继续执行可使用 return@forEach 这种
 *
 *如果是在匿名函数里边return 则只是终止匿名函数的执行 ，外层函数还能继续执行
 */
// 直接返回到这个外层函数
fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return // 非局部直接返回到 foo() 的调用者
        print(it)
    }
    println("this point is unreachable")
}

//kotlin 提供局部返回 ，使用标签来管理
fun foo1() {
    listOf(1, 2, 3, 4, 5).forEach lit@{
        if (it == 3) return@lit // 局部返回到该 lambda 表达式的调用者，即 forEach 循环
        print(it)
    }
    println(" done with explicit label")
}

fun foo2() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach // 局部返回到该 lambda 表达式的调用者，即 forEach 循环
        print(it)
    }
    print(" done with implicit label")
}

fun foo3() {
    listOf(1, 2, 3, 4, 5).forEach(fun(value: Int) {
        if (value == 3) return  // 局部返回到匿名函数的调用者，即 forEach 循环
        print(value)
    })
    print(" done with anonymous function")
}


//lambda表达式也可以通过下边方法来让外部函数继续使用
fun foo4() {
    run loop@{
        listOf(1, 2, 3, 4, 5).forEach {
            if (it == 3) return@loop // 从传入 run 的 lambda 表达式非局部返回 ，需要返回值的时候return@a 1这样即可
            print(it)
        }
    }
    print(" done with nested loop")
}

